home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML ConsoleMax.sea / XML ConsoleMax / Required / esc.jar / com / extensibility / rock / RTable.class (.txt) < prev    next >
Encoding:
Java Class File  |  2000-06-30  |  17.1 KB  |  828 lines
  1. package com.extensibility.rock;
  2.  
  3. import com.extensibility.app.UI;
  4. import com.extensibility.rock.table.QlickerCellEditor;
  5. import com.extensibility.rock.table.QlickerTable;
  6. import com.extensibility.util.Debug;
  7. import com.extensibility.xml.ParserException;
  8. import java.awt.Color;
  9. import java.awt.Component;
  10. import java.awt.Dimension;
  11. import java.awt.Font;
  12. import java.awt.Point;
  13. import java.awt.Rectangle;
  14. import java.awt.event.ComponentListener;
  15. import java.awt.event.FocusEvent;
  16. import java.awt.event.FocusListener;
  17. import java.awt.event.MouseEvent;
  18. import java.util.EventObject;
  19. import javax.swing.AbstractButton;
  20. import javax.swing.JCheckBox;
  21. import javax.swing.JComponent;
  22. import javax.swing.JPopupMenu;
  23. import javax.swing.JTable;
  24. import javax.swing.JViewport;
  25. import javax.swing.KeyStroke;
  26. import javax.swing.event.ChangeEvent;
  27. import javax.swing.event.ListSelectionListener;
  28. import javax.swing.event.TableModelEvent;
  29. import javax.swing.table.TableCellEditor;
  30. import javax.swing.table.TableCellRenderer;
  31. import javax.swing.table.TableColumn;
  32. import javax.swing.table.TableColumnModel;
  33. import javax.swing.table.TableModel;
  34. import javax.swing.text.JTextComponent;
  35.  
  36. public abstract class RTable extends JTable implements QlickerTable, FocusListener {
  37.    static final KeyStroke DELETE_KEY = KeyStroke.getKeyStroke(127, 0);
  38.    public static final String PROPERTY_EDIT_MODE = "EDIT_MODE";
  39.    public static final int MODE_ONE_CLICK = 1;
  40.    public static final int MODE_NO_EDIT = 2;
  41.    public static final int MODE_POP_DIALOG = 3;
  42.    int[] initialWidths;
  43.    double[] weights;
  44.    int columnCount;
  45.    int sumInitialWidths;
  46.    int lastEditingColumn;
  47.    boolean[] hidden;
  48.    int mode = 1;
  49.    private boolean bRemovingEditor = false;
  50.    boolean columnsSetup = false;
  51.    Component listenee;
  52.    ComponentListener resizeListener = new 4(this);
  53.    public ExpandAction expandAction = new ExpandAction(this);
  54.    public CutAction cutAction = new CutAction(this);
  55.    public CopyAction copyAction = new CopyAction(this);
  56.    public PasteAction pasteAction = new PasteAction(this);
  57.    public ClearAction clearAction = new ClearAction(this);
  58.    boolean isEnforcing;
  59.    boolean shrinkToFit = true;
  60.  
  61.    public abstract JPopupMenu createCellPopup(MouseEvent var1, int var2, int var3, TableCellEditor var4);
  62.  
  63.    public RTable(TableModel var1) {
  64.       super(var1);
  65.       this.prepare();
  66.    }
  67.  
  68.    protected void setSelectionForMode() {
  69.       if (this.isUnlocked()) {
  70.          ((JTable)this).setCellSelectionEnabled(true);
  71.          ((JTable)this).setSelectionMode(0);
  72.       } else {
  73.          ((JTable)this).setCellSelectionEnabled(false);
  74.          ((JTable)this).setSelectionMode(2);
  75.       }
  76.  
  77.    }
  78.  
  79.    protected void setupColumns() {
  80.       TableColumnModel var1 = ((JTable)this).getColumnModel();
  81.       this.columnCount = ((JTable)this).getModel().getColumnCount();
  82.       this.initialWidths = new int[this.columnCount];
  83.       this.weights = new double[this.columnCount];
  84.       if (this.hidden != null) {
  85.          boolean[] var2 = this.hidden;
  86.          this.hidden = new boolean[this.columnCount];
  87.          System.arraycopy(var2, 0, this.hidden, 0, Math.min(var2.length, this.hidden.length));
  88.       } else {
  89.          this.hidden = new boolean[this.columnCount];
  90.       }
  91.  
  92.       double var13 = (double)0.0F;
  93.       int var4 = var1.getColumnMargin();
  94.       this.sumInitialWidths = 0;
  95.  
  96.       for(int var5 = 0; var5 < this.columnCount; ++var5) {
  97.          TableColumn var6 = var1.getColumn(var5);
  98.          String var7 = (String)var6.getHeaderValue();
  99.          if (var7.indexOf(46) >= 0) {
  100.             var7 = UI.getString(var7);
  101.          }
  102.  
  103.          var6.setHeaderValue(var7);
  104.          TableCellRenderer var8 = this.createHeaderRenderer(var5);
  105.          if (var8 != null) {
  106.             var6.setHeaderRenderer(var8);
  107.          }
  108.  
  109.          TableCellRenderer var9 = this.createCellRenderer(var5);
  110.          if (var9 != null) {
  111.             var6.setCellRenderer(var9);
  112.          }
  113.  
  114.          TableCellEditor var10 = this.createCellEditor(var5);
  115.          if (var10 != null) {
  116.             var6.setCellEditor(var10);
  117.          }
  118.  
  119.          this.initialWidths[var5] = this.hidden[var5] ? 0 : this.getInitialColumnWidth(var5);
  120.          this.weights[var5] = this.hidden[var5] ? (double)0.0F : this.getColumnWeight(var5);
  121.          var13 += this.weights[var5];
  122.          if (this.initialWidths[var5] == 0) {
  123.             TableCellRenderer var11 = var6.getHeaderRenderer();
  124.             Component var12 = var11.getTableCellRendererComponent(this, var6.getHeaderValue(), false, false, -1, var5);
  125.             this.initialWidths[var5] = this.hidden[var5] ? 0 : var12.getPreferredSize().width;
  126.          }
  127.  
  128.          this.sumInitialWidths += this.initialWidths[var5] + var4;
  129.          if (this.weights[var5] == (double)0) {
  130.             var6.setResizable(false);
  131.          }
  132.  
  133.          var6.setMaxWidth(this.weights[var5] == (double)0 ? this.initialWidths[var5] : Integer.MAX_VALUE);
  134.          var6.setMinWidth(this.initialWidths[var5]);
  135.          var6.addPropertyChangeListener(new WidthChangeListener(this, var5));
  136.       }
  137.  
  138.       if (var13 != (double)1) {
  139.          double var14 = (double)1.0F / var13;
  140.  
  141.          for(int var15 = 0; var15 < this.columnCount; ++var15) {
  142.             this.weights[var15] *= var14;
  143.          }
  144.       }
  145.  
  146.    }
  147.  
  148.    private void prepare() {
  149.       this.setShrinkToFit(true);
  150.       ((JTable)this).setShowVerticalLines(false);
  151.       ((JTable)this).setGridColor(Color.lightGray);
  152.       ((JTable)this).setIntercellSpacing(new Dimension(0, 1));
  153.       ((JTable)this).getTableHeader().setReorderingAllowed(false);
  154.       this.setSelectionForMode();
  155.       ((JTable)this).setRowHeight(((JTable)this).getRowHeight() + 2);
  156.       ((Component)this).addMouseListener(new 1(this));
  157.       ((JTable)this).getTableHeader().addMouseListener(new 2(this));
  158.       JCheckBox var1 = new JCheckBox();
  159.       ((AbstractButton)var1).setHorizontalAlignment(0);
  160.       ((JTable)this).setDefaultEditor(Class.forName("java.lang.Boolean"), new BooleanCellEditor(this, var1));
  161.       this.addListSelectionListener(new 3(this));
  162.       ((JComponent)this).registerKeyboardAction(this.clearAction, "", DELETE_KEY, 0);
  163.       this.hidden = new boolean[((JTable)this).getColumnModel().getColumnCount()];
  164.       ((Component)this).addFocusListener(this);
  165.    }
  166.  
  167.    public void tableChanged(TableModelEvent var1) {
  168.       super.tableChanged(var1);
  169.       if (var1.getFirstRow() == -1 && ((Component)this).getParent() != null) {
  170.          this.setupColumns();
  171.          this.sizeColumnsToFit(-1);
  172.       }
  173.  
  174.    }
  175.  
  176.    protected void headerClick(MouseEvent var1, int var2) {
  177.    }
  178.  
  179.    protected void doCellPopup(MouseEvent var1) {
  180.       Point var4 = var1.getPoint();
  181.       int var5 = ((JTable)this).rowAtPoint(var4);
  182.       int var6 = ((JTable)this).columnAtPoint(var4);
  183.       if (var5 != -1 && var6 != -1) {
  184.          int var7 = ((JTable)this).getEditingRow();
  185.          int var8 = ((JTable)this).getEditingColumn();
  186.          TableCellEditor var3;
  187.          if (((JTable)this).getEditingColumn() == var6 && ((JTable)this).getEditingRow() == var5) {
  188.             var3 = ((JTable)this).getCellEditor();
  189.          } else {
  190.             var3 = ((JTable)this).getCellEditor(var5, var6);
  191.          }
  192.  
  193.          JPopupMenu var9 = this.createCellPopup(var1, var5, var6, var3);
  194.          if (var9 != null) {
  195.             var9.show(this, var4.x, var4.y);
  196.          }
  197.  
  198.       }
  199.    }
  200.  
  201.    public void showSelectedRow() {
  202.       int var1 = this.getSelectedRow();
  203.       if (var1 >= 0) {
  204.          this.showRow(var1);
  205.       }
  206.  
  207.    }
  208.  
  209.    public void showRow(int var1) {
  210.       Rectangle var2 = ((JTable)this).getCellRect(var1, 0, true);
  211.       ((JComponent)this).scrollRectToVisible(var2);
  212.    }
  213.  
  214.    public void showCell(int var1, int var2) {
  215.       Rectangle var3 = ((JTable)this).getCellRect(var1, var2, true);
  216.       ((JComponent)this).scrollRectToVisible(var3);
  217.    }
  218.  
  219.    public void addNotify() {
  220.       super.addNotify();
  221.       if (!this.columnsSetup) {
  222.          this.setupColumns();
  223.          this.adjustColumnWidths();
  224.          this.columnsSetup = true;
  225.       } else {
  226.          this.adjustColumnWidths();
  227.       }
  228.  
  229.       if (!this.isShrinkToFit()) {
  230.          this.listenee = ((Component)this).getParent() instanceof JViewport ? ((Component)this).getParent().getParent() : ((Component)this).getParent();
  231.          this.listenee.addComponentListener(this.resizeListener);
  232.       }
  233.  
  234.    }
  235.  
  236.    public void removeNotify() {
  237.       super.removeNotify();
  238.       if (this.listenee != null) {
  239.          this.listenee.removeComponentListener(this.resizeListener);
  240.       }
  241.  
  242.    }
  243.  
  244.    protected void processMouseMotionEvent(MouseEvent var1) {
  245.       try {
  246.          super.processMouseMotionEvent(var1);
  247.       } catch (IndexOutOfBoundsException var3) {
  248.       }
  249.  
  250.    }
  251.  
  252.    public void setFont(Font var1) {
  253.       int var2 = 0;
  254.       Font var3 = ((Component)this).getFont();
  255.       if (var3 != null) {
  256.          var2 = ((JTable)this).getRowHeight() - ((Component)this).getFontMetrics(var3).getHeight();
  257.       }
  258.  
  259.       super.setFont(var1);
  260.       int var4 = ((Component)this).getFontMetrics(var1).getHeight() + var2;
  261.       ((JTable)this).setRowHeight(var4);
  262.    }
  263.  
  264.    public boolean find(String var1, boolean var2) {
  265.       if (var2 && (this.getSelectedRow() == -1 || ((JTable)this).getSelectedColumn() == -1)) {
  266.          var2 = false;
  267.       }
  268.  
  269.       int var3 = ((JTable)this).getRowCount();
  270.       int var4 = ((JTable)this).getColumnCount();
  271.       int var5 = var2 ? this.getSelectedRow() : 0;
  272.       int var6 = var2 ? ((JTable)this).getSelectedColumn() : 0;
  273.       int var7 = var2 ? var5 : -1;
  274.       int var8 = var2 ? var6 : -1;
  275.       JTextComponent var9 = this.getCellEditorAsJTextComponent();
  276.       if (var2 && var9 != null) {
  277.          int var10 = var9.getSelectionEnd();
  278.          String var11 = var9.getText();
  279.          if (var10 < var11.length()) {
  280.             int var12 = var11.indexOf(var1, var10);
  281.             if (var12 >= 0) {
  282.                var9.select(var12, var12 + var1.length());
  283.                return true;
  284.             }
  285.          }
  286.       }
  287.  
  288.       while(var5 < var3) {
  289.          for(int var13 = 0; var13 < var4; ++var13) {
  290.             if (this.searchable(var5, var13) && ((JTable)this).getModel().getColumnClass(var13) == Class.forName("java.lang.String") && (var5 != var7 || var13 > var8)) {
  291.                String var14 = (String)((JTable)this).getModel().getValueAt(var5, var13);
  292.                if (var14 != null && var14.indexOf(var1) >= 0) {
  293.                   return this.select(var5, var13, var1);
  294.                }
  295.             }
  296.          }
  297.  
  298.          ++var5;
  299.       }
  300.  
  301.       if (var2) {
  302.          return this.find(var1, false);
  303.       } else {
  304.          ((Component)this).getToolkit().beep();
  305.          return false;
  306.       }
  307.    }
  308.  
  309.    public void updateEditor() {
  310.       this.updateEditor(true);
  311.    }
  312.  
  313.    public void updateEditor(boolean var1) {
  314.       JTextComponent var2 = this.getCellEditorAsJTextComponent();
  315.       if (var2 != null) {
  316.          Object var3 = ((JTable)this).getValueAt(((JTable)this).getEditingRow(), ((JTable)this).getEditingColumn());
  317.          String var4 = var3 == null ? "" : (String)var3;
  318.          var2.setText(var4);
  319.       } else if (var1) {
  320.          int var5 = ((JTable)this).getEditingRow();
  321.          int var6 = ((JTable)this).getEditingColumn();
  322.          if (var5 >= 0 && var6 >= 0) {
  323.             this.cancelEditing();
  324.             this.editCellAt(var5, var6);
  325.          }
  326.       }
  327.  
  328.    }
  329.  
  330.    public boolean searchable(int var1, int var2) {
  331.       return true;
  332.    }
  333.  
  334.    public JTextComponent getCellEditorAsJTextComponent() {
  335.       if (((JTable)this).getCellEditor() instanceof JTextComponent) {
  336.          return (JTextComponent)((JTable)this).getCellEditor();
  337.       } else {
  338.          return ((JTable)this).getEditorComponent() instanceof JTextComponent ? (JTextComponent)((JTable)this).getEditorComponent() : null;
  339.       }
  340.    }
  341.  
  342.    public boolean commitPendingEdits(boolean var1) {
  343.       int var2 = ((JTable)this).getEditingRow();
  344.       int var3 = ((JTable)this).getEditingColumn();
  345.       if (var2 != -1 && var3 != -1) {
  346.          if (!this.stopEditing()) {
  347.             return false;
  348.          } else {
  349.             return var1 ? this.editCellAt(var2, var3, true) : true;
  350.          }
  351.       } else {
  352.          return true;
  353.       }
  354.    }
  355.  
  356.    private void updateEditActions() {
  357.       this.cutAction.updateEnabled();
  358.       this.copyAction.setEnabled(this.cutAction.isEnabled());
  359.       this.pasteAction.updateEnabled();
  360.       this.clearAction.setEnabled(this.cutAction.isEnabled());
  361.    }
  362.  
  363.    public abstract boolean pasteable();
  364.  
  365.    public abstract void cut();
  366.  
  367.    public abstract void copy();
  368.  
  369.    public abstract void paste();
  370.  
  371.    public abstract void clear();
  372.  
  373.    public void goNextCell(boolean var1, boolean var2) {
  374.       int var3 = ((JTable)this).getEditingRow();
  375.       int var4 = ((JTable)this).getEditingColumn();
  376.       int var5 = var3;
  377.       int var6 = var4;
  378.       var3 = Math.max(var3, 0);
  379.       var4 = Math.max(var4, 0);
  380.       if (this.stopEditing()) {
  381.          int var7 = ((JTable)this).getColumnCount();
  382.          int var8 = ((JTable)this).getRowCount();
  383.          if (!var2) {
  384.             if (var1) {
  385.                ++var3;
  386.  
  387.                while(var3 < var8) {
  388.                   if (((JTable)this).isCellEditable(var3, var4)) {
  389.                      this.editCellAt(var3, var4, true);
  390.                      return;
  391.                   }
  392.  
  393.                   ++var3;
  394.                }
  395.             } else {
  396.                --var3;
  397.  
  398.                for(int var13 = Math.max(var3, 0); var13 >= 0; --var13) {
  399.                   if (((JTable)this).isCellEditable(var13, var4)) {
  400.                      this.editCellAt(var13, var4, true);
  401.                      return;
  402.                   }
  403.                }
  404.             }
  405.          } else if (var1) {
  406.             while(var3 < var8) {
  407.                while(var4 < var7) {
  408.                   if (!this.hidden[var4] && ((JTable)this).getModel().getColumnClass(var4) != Class.forName("java.lang.Boolean") && ((JTable)this).isCellEditable(var3, var4) && (var3 != var5 || var4 != var6)) {
  409.                      this.editCellAt(var3, var4, true);
  410.                      return;
  411.                   }
  412.  
  413.                   ++var4;
  414.                }
  415.  
  416.                var4 = 0;
  417.                ++var3;
  418.             }
  419.          } else {
  420.             while(var3 >= 0) {
  421.                while(var4 > 0) {
  422.                   if (!this.hidden[var4] && ((JTable)this).getModel().getColumnClass(var4) != Class.forName("java.lang.Boolean") && ((JTable)this).isCellEditable(var3, var4) && (var3 != var5 || var4 != var6)) {
  423.                      this.editCellAt(var3, var4, true);
  424.                      return;
  425.                   }
  426.  
  427.                   --var4;
  428.                }
  429.  
  430.                var4 = var7 - 1;
  431.                --var3;
  432.             }
  433.          }
  434.  
  435.          this.editCellAt(var5, var6, true);
  436.       }
  437.    }
  438.  
  439.    public void cancelEditing() {
  440.       TableCellEditor var1 = ((JTable)this).getCellEditor();
  441.       if (var1 != null) {
  442.          this.lastEditingColumn = -1;
  443.          var1.cancelCellEditing();
  444.       }
  445.  
  446.    }
  447.  
  448.    public boolean stopEditing() {
  449.       TableCellEditor var1 = ((JTable)this).getCellEditor();
  450.       if (var1 != null) {
  451.          this.lastEditingColumn = -1;
  452.          return var1.stopCellEditing();
  453.       } else {
  454.          return true;
  455.       }
  456.    }
  457.  
  458.    public int getEditMode() {
  459.       return this.mode;
  460.    }
  461.  
  462.    public boolean isUnlocked() {
  463.       return this.mode != 2;
  464.    }
  465.  
  466.    public boolean setEditMode(int var1) {
  467.       TableCellEditor var2 = ((JTable)this).getCellEditor();
  468.       if (var1 == this.mode) {
  469.          return true;
  470.       } else {
  471.          Integer var3 = new Integer(this.mode);
  472.          if (var2 != null && var1 != 1) {
  473.             if (!var2.stopCellEditing()) {
  474.                return false;
  475.             }
  476.  
  477.             this.editingStopped(new ChangeEvent(var2));
  478.             this.mode = var1;
  479.             int var6 = this.getSelectedRow();
  480.             this.setSelectionForMode();
  481.             this.select(var6);
  482.          } else if (var2 == null && var1 == 1) {
  483.             int var4 = this.getSelectedRow();
  484.             int var5 = ((JTable)this).getSelectedColumn();
  485.             this.mode = var1;
  486.             this.setSelectionForMode();
  487.             if (var4 >= 0 && var5 >= 0) {
  488.                this.editCellAt(var4, var5);
  489.             }
  490.          } else {
  491.             this.mode = var1;
  492.             this.setSelectionForMode();
  493.          }
  494.  
  495.          this.updateEditActions();
  496.          ((JComponent)this).firePropertyChange("EDIT_MODE", var3, new Integer(var1));
  497.          return true;
  498.       }
  499.    }
  500.  
  501.    public boolean showCellDialog(int var1, int var2, EventObject var3) {
  502.       return false;
  503.    }
  504.  
  505.    public boolean hasCellDialog(int var1, int var2) {
  506.       return false;
  507.    }
  508.  
  509.    public void removeEditor() {
  510.       this.bRemovingEditor = true;
  511.       super.removeEditor();
  512.       this.bRemovingEditor = false;
  513.    }
  514.  
  515.    public boolean editCellAt(int var1, int var2, boolean var3) {
  516.       boolean var4 = this.editCellAt(var1, var2, (EventObject)null);
  517.       if (var3) {
  518.          JTextComponent var5 = this.getCellEditorAsJTextComponent();
  519.          if (var5 != null) {
  520.             var5.select(0, Integer.MAX_VALUE);
  521.          }
  522.       }
  523.  
  524.       return var4;
  525.    }
  526.  
  527.    public boolean editCellAt(int var1, int var2) {
  528.       return this.editCellAt(var1, var2, (EventObject)null);
  529.    }
  530.  
  531.    public boolean editCellAt(int var1, int var2, EventObject var3) {
  532.       Debug.assert(var1 >= 0 && var2 >= 0, "can't edit -1");
  533.       this.showCell(var1, var2);
  534.       if (!this.isUnlocked() && var3 != null) {
  535.          return false;
  536.       } else {
  537.          boolean var4;
  538.          if (this.mode == 3) {
  539.             if (!this.stopEditing()) {
  540.                var4 = false;
  541.             } else if (!this.showCellDialog(var1, var2, var3)) {
  542.                var4 = super.editCellAt(var1, var2, var3);
  543.             } else {
  544.                var4 = false;
  545.             }
  546.          } else {
  547.             var4 = super.editCellAt(var1, var2, var3);
  548.          }
  549.  
  550.          this.enforceEditorCellSelection();
  551.          if (((JTable)this).getCellEditor() != null && ((JTable)this).getCellEditor() instanceof Component) {
  552.             ((Component)((JTable)this).getCellEditor()).requestFocus();
  553.          }
  554.  
  555.          if (var4) {
  556.             this.lastEditingColumn = var2;
  557.          } else {
  558.             this.lastEditingColumn = -1;
  559.          }
  560.  
  561.          this.updateEditActions();
  562.          return var4;
  563.       }
  564.    }
  565.  
  566.    public int getLastEditingColumn() {
  567.       return this.lastEditingColumn;
  568.    }
  569.  
  570.    public void enforceEditorCellSelection() {
  571.       if (this.isUnlocked()) {
  572.          this.enforceEditorCellSelection(((JTable)this).getEditingRow(), ((JTable)this).getEditingColumn());
  573.       }
  574.  
  575.    }
  576.  
  577.    public int getSelectedRow() {
  578.       int[] var1 = ((JTable)this).getSelectedRows();
  579.       return var1.length == 0 ? -1 : var1[0];
  580.    }
  581.  
  582.    protected void enforceEditorCellSelection(int var1, int var2) {
  583.       if (!this.isEnforcing && this.isUnlocked()) {
  584.          if (var1 >= 0 && var2 >= 0) {
  585.             if (var1 != this.getSelectedRow() || var2 != ((JTable)this).getSelectedColumn()) {
  586.                try {
  587.                   this.isEnforcing = true;
  588.                   ((JTable)this).clearSelection();
  589.                   if (var1 != this.getSelectedRow()) {
  590.                      ((JTable)this).addRowSelectionInterval(var1, var1);
  591.                   }
  592.  
  593.                   if (var2 != ((JTable)this).getSelectedColumn()) {
  594.                      ((JTable)this).addColumnSelectionInterval(var2, var2);
  595.                   }
  596.                } finally {
  597.                   this.isEnforcing = false;
  598.                }
  599.  
  600.             }
  601.          }
  602.       }
  603.    }
  604.  
  605.    public void editingCanceled(ChangeEvent var1) {
  606.       this.lastEditingColumn = -1;
  607.       super.editingCanceled(var1);
  608.       this.updateEditActions();
  609.    }
  610.  
  611.    public void editingStopped(ChangeEvent var1) {
  612.       this.lastEditingColumn = -1;
  613.       this.bRemovingEditor = true;
  614.       ((JComponent)this).requestFocus();
  615.       super.editingStopped(var1);
  616.       this.updateEditActions();
  617.    }
  618.  
  619.    public ParserException validateCell(String var1) {
  620.       return null;
  621.    }
  622.  
  623.    public TableCellRenderer createHeaderRenderer(int var1) {
  624.       return null;
  625.    }
  626.  
  627.    public TableCellRenderer createCellRenderer(int var1) {
  628.       return null;
  629.    }
  630.  
  631.    public TableCellEditor createCellEditor(int var1) {
  632.       return null;
  633.    }
  634.  
  635.    public int getInitialColumnWidth(int var1) {
  636.       return 0;
  637.    }
  638.  
  639.    public double getColumnWeight(int var1) {
  640.       return (double)(1 / this.columnCount);
  641.    }
  642.  
  643.    public void showHideColumn(int var1, boolean var2) {
  644.       if (var2) {
  645.          this.showColumn(var1);
  646.       } else {
  647.          this.hideColumn(var1);
  648.       }
  649.  
  650.    }
  651.  
  652.    public void hideColumn(int var1) {
  653.       this.hidden[var1] = true;
  654.       if (this.columnsSetup) {
  655.          this.sizeColumnsToFit(-1);
  656.       }
  657.  
  658.       if (((JTable)this).getEditingColumn() == var1) {
  659.          this.goNextCell(true, true);
  660.       }
  661.  
  662.    }
  663.  
  664.    public void showColumn(int var1) {
  665.       this.hidden[var1] = false;
  666.       if (this.columnsSetup) {
  667.          this.sizeColumnsToFit(-1);
  668.       }
  669.  
  670.    }
  671.  
  672.    public boolean isHidden(int var1) {
  673.       return this.hidden[var1];
  674.    }
  675.  
  676.    public Object getQlickerData(String var1, Class var2) {
  677.       return null;
  678.    }
  679.  
  680.    public void sizeColumnsToFit(int var1) {
  681.       if (var1 == -1) {
  682.          this.adjustColumnWidths();
  683.       }
  684.  
  685.       super.sizeColumnsToFit(var1);
  686.    }
  687.  
  688.    public boolean isShrinkToFit() {
  689.       return this.shrinkToFit;
  690.    }
  691.  
  692.    public void setShrinkToFit(boolean var1) {
  693.       this.shrinkToFit = var1;
  694.       if (this.shrinkToFit) {
  695.          ((JTable)this).setAutoResizeMode(2);
  696.       } else {
  697.          ((JTable)this).setAutoResizeMode(0);
  698.       }
  699.  
  700.    }
  701.  
  702.    void adjustColumnWidths() {
  703.       TableColumnModel var1 = ((JTable)this).getColumnModel();
  704.       int var2 = var1.getColumnMargin();
  705.       int var3 = ((JViewport)((Component)this).getParent()).getExtentSize().width;
  706.       int var4 = var3 - this.sumInitialWidths;
  707.       int var5 = 0;
  708.  
  709.       for(int var6 = 0; var6 < this.columnCount; ++var6) {
  710.          if (this.hidden[var6]) {
  711.             var1.getColumn(var6).setPreferredWidth(0);
  712.          } else {
  713.             int var7 = (int)((double)this.initialWidths[var6] + (double)var4 * this.weights[var6]);
  714.             int var8 = var7;
  715.             if (!this.isShrinkToFit()) {
  716.                var8 = Math.max(var7, this.initialWidths[var6]);
  717.                var7 = Math.max(var7, Math.max(var1.getColumn(var6).getPreferredWidth(), this.initialWidths[var6]));
  718.             }
  719.  
  720.             if (var6 < this.columnCount - 1) {
  721.                var5 += var7 + var2;
  722.             } else if (this.isShrinkToFit() || var5 + var7 < var3) {
  723.                var7 = var3 - var5;
  724.             }
  725.  
  726.             var1.getColumn(var6).setPreferredWidth(var7);
  727.             var1.getColumn(var6).setMinWidth(var8);
  728.          }
  729.       }
  730.  
  731.    }
  732.  
  733.    public final void addListSelectionListener(ListSelectionListener var1) {
  734.       ((JTable)this).getSelectionModel().addListSelectionListener(var1);
  735.    }
  736.  
  737.    public final void removeListSelectionListener(ListSelectionListener var1) {
  738.       ((JTable)this).getSelectionModel().removeListSelectionListener(var1);
  739.    }
  740.  
  741.    public boolean select(int var1) {
  742.       return this.select(var1, ((JTable)this).getSelectedColumn());
  743.    }
  744.  
  745.    public boolean clearSelectionAndEditing() {
  746.       if (((JTable)this).getCellEditor() != null && !((JTable)this).getCellEditor().stopCellEditing()) {
  747.          return false;
  748.       } else {
  749.          ((JTable)this).clearSelection();
  750.          return true;
  751.       }
  752.    }
  753.  
  754.    public boolean select(int var1, int var2) {
  755.       if (var1 < 0) {
  756.          var1 = 0;
  757.       }
  758.  
  759.       if (var2 < 0) {
  760.          var2 = 0;
  761.       }
  762.  
  763.       boolean var3;
  764.       if (this.isUnlocked()) {
  765.          var3 = this.editCellAt(var1, var2, true);
  766.          if (!var3 && !((JTable)this).isEditing() && !((JTable)this).isCellEditable(var1, var2)) {
  767.             this.enforceEditorCellSelection(var1, var2);
  768.             var3 = true;
  769.          }
  770.       } else {
  771.          ((JTable)this).clearSelection();
  772.          ((JTable)this).setRowSelectionAllowed(true);
  773.          ((JTable)this).addRowSelectionInterval(var1, var1);
  774.          ((JComponent)this).requestFocus();
  775.          var3 = true;
  776.       }
  777.  
  778.       if (var3) {
  779.          this.showCell(var1, var2);
  780.       }
  781.  
  782.       return var3;
  783.    }
  784.  
  785.    public boolean selectCellOnly(int var1, int var2) {
  786.       if (this.isUnlocked()) {
  787.          this.enforceEditorCellSelection(var1, var2);
  788.       } else {
  789.          ((JTable)this).clearSelection();
  790.          ((JTable)this).addRowSelectionInterval(var1, var1);
  791.          ((JComponent)this).requestFocus();
  792.       }
  793.  
  794.       this.showCell(var1, var2);
  795.       return true;
  796.    }
  797.  
  798.    public boolean select(int var1, int var2, String var3) {
  799.       if (!this.isUnlocked() && !this.setEditMode(1)) {
  800.          return false;
  801.       } else {
  802.          boolean var4 = this.select(var1, var2);
  803.          if (((JTable)this).getCellEditor() instanceof QlickerCellEditor) {
  804.             ((QlickerCellEditor)((JTable)this).getCellEditor()).select(var3);
  805.          }
  806.  
  807.          return var4;
  808.       }
  809.    }
  810.  
  811.    public void focusGained(FocusEvent var1) {
  812.       if (!this.bRemovingEditor && ((JTable)this).getSelectedColumnCount() == 1 && ((JTable)this).getSelectedRowCount() == 1) {
  813.          int var2 = this.getSelectedRow();
  814.          int var3 = ((JTable)this).getSelectedColumn();
  815.          this.editCellAt(var2, var3, true);
  816.       }
  817.  
  818.    }
  819.  
  820.    public void focusLost(FocusEvent var1) {
  821.    }
  822.  
  823.    // $FF: synthetic method
  824.    static void access$5000071(RTable var0) {
  825.       var0.updateEditActions();
  826.    }
  827. }
  828.